```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Java命名规范全解析 - 专业开发者必备指南</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.6;
        }
        h1, h2, h3, h4 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
            color: #1a202c;
        }
        .hero-gradient {
            background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%);
        }
        .card-hover {
            transition: all 0.3s ease;
        }
        .card-hover:hover {
            transform: translateY(-5px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .highlight-box {
            background-color: #f0f9ff;
            border-left: 4px solid #3b82f6;
        }
        .drop-cap:first-letter {
            float: left;
            font-size: 3.5em;
            line-height: 0.8;
            margin: 0.1em 0.1em 0.1em 0;
            color: #4f46e5;
            font-weight: 700;
        }
        table {
            width: 100%;
            border-collapse: collapse;
            margin: 1.5rem 0;
        }
        th {
            background-color: #f8fafc;
            font-weight: 600;
            text-align: left;
        }
        th, td {
            padding: 12px 15px;
            border: 1px solid #e2e8f0;
        }
        tr:nth-child(even) {
            background-color: #f8fafc;
        }
        .nav-link {
            position: relative;
        }
        .nav-link:after {
            content: '';
            position: absolute;
            width: 0;
            height: 2px;
            bottom: 0;
            left: 0;
            background-color: #4f46e5;
            transition: width 0.3s ease;
        }
        .nav-link:hover:after {
            width: 100%;
        }
        .footer-link:hover {
            color: #a5b4fc;
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <header class="hero-gradient text-white py-20 px-4 sm:px-6 lg:px-8">
        <div class="max-w-5xl mx-auto text-center">
            <h1 class="text-4xl md:text-5xl font-bold mb-6">90% Java开发者忽略的命名规范全梳理</h1>
            <p class="text-xl md:text-2xl mb-8 opacity-90">专业代码与业余代码的分水岭，从规范命名开始</p>
            <div class="inline-block bg-white bg-opacity-20 backdrop-filter backdrop-blur-sm rounded-lg px-6 py-3">
                <p class="font-medium flex items-center justify-center">
                    <i class="fas fa-exclamation-triangle mr-2"></i>
                    警告：阅读本文可能会让你对自己过去写的代码产生深深的愧疚感
                </p>
            </div>
        </div>
    </header>

    <!-- Main Content -->
    <main class="max-w-6xl mx-auto px-4 sm:px-6 lg:px-8 py-12">
        <!-- Intro Section -->
        <section class="mb-16">
            <div class="bg-white rounded-xl shadow-md overflow-hidden card-hover">
                <div class="md:flex">
                    <div class="md:w-1/2 p-8">
                        <h2 class="text-2xl font-bold mb-4">命名规范的重要性</h2>
                        <div class="drop-cap text-gray-700 mb-6">
                            你可能认为命名只是代码风格问题，不值得花太多时间。但知道吗？大型科技公司面试中，有超过35%的候选人因命名不规范而被直接淘汰。
                        </div>
                        <p class="mb-4">更有争议的是，我曾见过一个Java团队为一个变量命名争论两小时，最终升级为技术委员会投票决定。这真的值得吗？</p>
                        <div class="flex flex-wrap gap-2 mb-6">
                            <span class="bg-purple-100 text-purple-800 px-3 py-1 rounded-full text-sm">代码可读性</span>
                            <span class="bg-blue-100 text-blue-800 px-3 py-1 rounded-full text-sm">团队协作</span>
                            <span class="bg-green-100 text-green-800 px-3 py-1 rounded-full text-sm">维护成本</span>
                            <span class="bg-yellow-100 text-yellow-800 px-3 py-1 rounded-full text-sm">面试考核</span>
                        </div>
                    </div>
                    <div class="md:w-1/2 bg-gray-100 flex items-center justify-center p-4">
                        <img src="https://cdn.nlark.com/yuque/0/2025/png/21449790/1744954738806-3d53fa43-fef9-4b49-8be9-58d927e1c91b.png" alt="Java命名规范对比" class="rounded-lg shadow-sm max-h-80">
                    </div>
                </div>
                <div class="px-8 py-6 bg-gray-50 border-t border-gray-200">
                    <p class="text-gray-600">
                        <i class="fas fa-info-circle text-blue-500 mr-1"></i>
                        Google和阿里巴巴的Java命名标准在某些关键点上完全相反。你遵循哪一套？或者你的团队在不知不觉中创造了自己的"非标准标准"？
                    </p>
                </div>
            </div>
        </section>

        <!-- Table of Contents -->
        <section class="mb-16 bg-white rounded-xl shadow-md overflow-hidden card-hover">
            <div class="p-8">
                <h2 class="text-2xl font-bold mb-6 flex items-center">
                    <i class="fas fa-list-ul text-purple-500 mr-3"></i>
                    文章目录
                </h2>
                <div class="grid md:grid-cols-2 gap-6">
                    <div>
                        <h3 class="text-lg font-semibold mb-3 text-gray-700">一、基本原则与思维方式</h3>
                        <ul class="space-y-2">
                            <li><a href="#philosophy" class="text-blue-600 hover:text-blue-800 nav-link">命名哲学对比表</a></li>
                            <li><a href="#standards" class="text-blue-600 hover:text-blue-800 nav-link">业界权威标准对比</a></li>
                            <li><a href="#hungarian" class="text-blue-600 hover:text-blue-800 nav-link">匈牙利命名法详解</a></li>
                        </ul>
                    </div>
                    <div>
                        <h3 class="text-lg font-semibold mb-3 text-gray-700">二、类与接口的命名规范</h3>
                        <ul class="space-y-2">
                            <li><a href="#class-naming" class="text-blue-600 hover:text-blue-800 nav-link">类型命名模式对照表</a></li>
                            <li><a href="#class-mistakes" class="text-blue-600 hover:text-blue-800 nav-link">类名常见错误与修正指南</a></li>
                        </ul>
                    </div>
                    <div>
                        <h3 class="text-lg font-semibold mb-3 text-gray-700">三、方法命名的艺术</h3>
                        <ul class="space-y-2">
                            <li><a href="#method-prefixes" class="text-blue-600 hover:text-blue-800 nav-link">方法命名动词前缀参考</a></li>
                            <li><a href="#special-methods" class="text-blue-600 hover:text-blue-800 nav-link">特殊方法命名约定表</a></li>
                            <li><a href="#method-examples" class="text-blue-600 hover:text-blue-800 nav-link">方法命名的对比示例</a></li>
                        </ul>
                    </div>
                    <div>
                        <h3 class="text-lg font-semibold mb-3 text-gray-700">四、变量命名的系统规范</h3>
                        <ul class="space-y-2">
                            <li><a href="#variable-types" class="text-blue-600 hover:text-blue-800 nav-link">变量类型命名规则表</a></li>
                            <li><a href="#collection-naming" class="text-blue-600 hover:text-blue-800 nav-link">集合变量命名最佳实践</a></li>
                        </ul>
                    </div>
                </div>
            </div>
        </section>

        <!-- Section 1 -->
        <section id="philosophy" class="mb-16">
            <h2 class="text-3xl font-bold mb-6 flex items-center">
                <span class="bg-purple-100 text-purple-800 w-10 h-10 rounded-full flex items-center justify-center mr-4">1</span>
                一、Java命名的基本原则与思维方式
            </h2>
            
            <h3 class="text-2xl font-semibold mb-4 text-gray-800">命名哲学对比表</h3>
            <p class="mb-6 text-gray-700">不同的命名理念会导致截然不同的代码风格和可维护性。以下是主流命名哲学的对比：</p>
            
            <div class="overflow-x-auto bg-white rounded-lg shadow-md card-hover">
                <table>
                    <thead>
                        <tr>
                            <th>命名哲学</th>
                            <th>核心观点</th>
                            <th>优点</th>
                            <th>缺点</th>
                            <th>适用场景</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td><strong>简洁至上</strong></td>
                            <td>名称越短越好</td>
                            <td>节省输入时间，代码更紧凑</td>
                            <td>可能导致含义不明，维护困难</td>
                            <td>生命周期短的临时变量，小规模个人项目</td>
                        </tr>
                        <tr>
                            <td><strong>描述性优先</strong></td>
                            <td>名称应完整描述其用途</td>
                            <td>自解释，减少注释需求</td>
                            <td>名称可能过长，降低代码简洁度</td>
                            <td>大型团队项目，核心业务逻辑</td>
                        </tr>
                        <tr>
                            <td><strong>域特定语言</strong></td>
                            <td>名称应反映业务领域术语</td>
                            <td>与业务人员沟通更容易</td>
                            <td>技术人员可能不熟悉业务术语</td>
                            <td>DDD项目，业务复杂度高的系统</td>
                        </tr>
                        <tr>
                            <td><strong>匈牙利命名法</strong></td>
                            <td>变量名前缀表示类型</td>
                            <td>快速识别变量类型</td>
                            <td>现代IDE已能显示类型，增加冗余</td>
                            <td>遗留系统，对类型安全特别关注的场景</td>
                        </tr>
                    </tbody>
                </table>
            </div>
            
            <div class="mt-6 p-6 bg-blue-50 rounded-lg border border-blue-200">
                <p class="text-blue-800">
                    <i class="fas fa-lightbulb text-blue-500 mr-2"></i>
                    <strong>专家建议：</strong> 在实际项目中，"描述性优先"往往是大型团队项目的最佳选择，而"简洁至上"可能会在维护阶段造成巨大的理解成本。当然，理想的命名应该在描述性和简洁性之间找到平衡点。
                </p>
            </div>
        </section>

        <!-- Section 2 -->
        <section id="standards" class="mb-16">
            <h3 class="text-2xl font-semibold mb-4 text-gray-800">业界权威标准对比</h3>
            <p class="mb-6 text-gray-700">各大技术公司和组织都有自己的Java编码规范，虽然基本原则相似，但在一些细节上有所差异：</p>
            
            <div class="overflow-x-auto bg-white rounded-lg shadow-md card-hover">
                <table>
                    <thead>
                        <tr>
                            <th>规范来源</th>
                            <th>类命名</th>
                            <th>方法命名</th>
                            <th>变量命名</th>
                            <th>常量命名</th>
                            <th>特殊规定</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td><strong>Google</strong></td>
                            <td>PascalCase</td>
                            <td>camelCase</td>
                            <td>camelCase</td>
                            <td>UPPER_SNAKE_CASE</td>
                            <td>不使用匈牙利命名法</td>
                        </tr>
                        <tr>
                            <td><strong>Oracle</strong></td>
                            <td>PascalCase</td>
                            <td>camelCase</td>
                            <td>camelCase</td>
                            <td>UPPER_SNAKE_CASE</td>
                            <td>包名全小写</td>
                        </tr>
                        <tr>
                            <td><strong>阿里巴巴</strong></td>
                            <td>PascalCase</td>
                            <td>camelCase</td>
                            <td>camelCase</td>
                            <td>UPPER_SNAKE_CASE</td>
                            <td>禁止使用拼音命名</td>
                        </tr>
                        <tr>
                            <td><strong>Spring源码</strong></td>
                            <td>PascalCase</td>
                            <td>camelCase</td>
                            <td>camelCase</td>
                            <td>UPPER_SNAKE_CASE</td>
                            <td>接口不使用"I"前缀</td>
                        </tr>
                    </tbody>
                </table>
            </div>
            
            <div class="mt-6 p-6 bg-white rounded-lg shadow-sm border border-gray-200">
                <p class="text-gray-700 mb-2">
                    <i class="fas fa-check-circle text-green-500 mr-2"></i>
                    可以看出，主流规范在基本命名风格上达成了一致，差异主要在特殊规定和一些细节处理上。作为团队，选择一个权威标准并严格执行，比创建自己的"特色标准"更为明智。
                </p>
            </div>
        </section>

        <!-- Hungarian Notation Section -->
        <section id="hungarian" class="mb-16 bg-white rounded-xl shadow-md overflow-hidden card-hover">
            <div class="p-8">
                <h3 class="text-2xl font-semibold mb-4 text-gray-800 flex items-center">
                    <i class="fas fa-question-circle text-purple-500 mr-2"></i>
                    什么叫做匈牙利命名法？
                </h3>
                <div class="bg-gray-50 p-6 rounded-lg">
                    <p class="font-medium text-gray-800 mb-4">
                        <strong>匈牙利命名法</strong>（Hungarian Notation）是一种编程中的变量命名规则，核心思想是：
                        <span class="bg-blue-100 px-2 py-1 rounded">在变量名前加前缀，标明变量的类型或用途</span>，让代码更易读、减少错误。
                    </p>
                    
                    <p class="mb-4 text-gray-700">在变量名前加小写字母，表示数据类型：</p>
                    
                    <div class="grid md:grid-cols-2 gap-4">
                        <div class="bg-gray-100 p-4 rounded-lg">
                            <p class="font-mono text-sm">
                                <span class="text-purple-700">i</span> → 整型（integer）：
                                <br><span class="bg-gray-200 px-2 py-1 rounded">iCount = 10</span>
                            </p>
                        </div>
                        <div class="bg-gray-100 p-4 rounded-lg">
                            <p class="font-mono text-sm">
                                <span class="text-purple-700">f</span> → 浮点型（float）：
                                <br><span class="bg-gray-200 px-2 py-1 rounded">fPrice = 3.14</span>
                            </p>
                        </div>
                        <div class="bg-gray-100 p-4 rounded-lg">
                            <p class="font-mono text-sm">
                                <span class="text-purple-700">sz</span> → 字符串（string zero-terminated）：
                                <br><span class="bg-gray-200 px-2 py-1 rounded">szName = "张三"</span>
                            </p>
                        </div>
                        <div class="bg-gray-100 p-4 rounded-lg">
                            <p class="font-mono text-sm">
                                <span class="text-purple-700">b</span> → 布尔型（boolean）：
                                <br><span class="bg-gray-200 px-2 py-1 rounded">bIsReady = true</span>
                            </p>
                        </div>
                    </div>
                    
                    <div class="mt-6 p-4 bg-yellow-50 border-l-4 border-yellow-400 rounded">
                        <p class="text-yellow-800">
                            <i class="fas fa-exclamation-triangle text-yellow-500 mr-2"></i>
                            <strong>注意：</strong> 匈牙利命名法在现代Java开发中已不再推荐使用，因为现代IDE能够很好地显示变量类型，而且这种命名方式会使代码变得冗长。
                        </p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Section 2: Class Naming -->
        <section id="class-naming" class="mb-16">
            <h2 class="text-3xl font-bold mb-6 flex items-center">
                <span class="bg-purple-100 text-purple-800 w-10 h-10 rounded-full flex items-center justify-center mr-4">2</span>
                二、类与接口的命名规范实战
            </h2>
            
            <h3 class="text-2xl font-semibold mb-4 text-gray-800">类型命名模式对照表</h3>
            <p class="mb-6 text-gray-700">Java中不同类型的类有着不同的命名模式，遵循这些约定可以让代码更具可读性：</p>
            
            <div class="overflow-x-auto bg-white rounded-lg shadow-md card-hover">
                <table>
                    <thead>
                        <tr>
                            <th>类型</th>
                            <th>命名模式</th>
                            <th>示例</th>
                            <th>反例</th>
                            <th>说明</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td><strong>普通类</strong></td>
                            <td>PascalCase名词或名词短语</td>
                            <td><code>OrderProcessor</code>, <code>Customer</code></td>
                            <td><code>ProcessOrder</code>, <code>customer</code></td>
                            <td>应表达"是什么"而非"做什么"</td>
                        </tr>
                        <tr>
                            <td><strong>接口</strong></td>
                            <td>PascalCase能力或不加修饰</td>
                            <td><code>Runnable</code>, <code>Serializable</code>, <code>List</code></td>
                            <td><code>IList</code>, <code>ListInterface</code></td>
                            <td>现代Java不推荐"I"前缀</td>
                        </tr>
                        <tr>
                            <td><strong>抽象类</strong></td>
                            <td>Abstract+名词</td>
                            <td><code>AbstractList</code>, <code>AbstractFactory</code></td>
                            <td><code>ListBase</code>, <code>BasicFactory</code></td>
                            <td>清晰表明不可实例化</td>
                        </tr>
                        <tr>
                            <td><strong>异常类</strong></td>
                            <td>PascalCase+Exception</td>
                            <td><code>OrderNotFoundException</code></td>
                            <td><code>NotFound</code>, <code>OrderError</code></td>
                            <td>必须继承自Exception体系</td>
                        </tr>
                        <tr>
                            <td><strong>测试类</strong></td>
                            <td>被测类名+Test</td>
                            <td><code>OrderServiceTest</code></td>
                            <td><code>TestOrder</code>, <code>OrderTest1</code></td>
                            <td>清晰对应被测试的类</td>
                        </tr>
                        <tr>
                            <td><strong>枚举类</strong></td>
                            <td>PascalCase名词</td>
                            <td><code>Color</code>, <code>OrderStatus</code></td>
                            <td><code>COLORS</code>, <code>orderTypes</code></td>
                            <td>单数形式，表示类型而非集合</td>
                        </tr>
                    </tbody>
                </table>
            </div>
            
            <div class="mt-6 p-6 bg-blue-50 rounded-lg border border-blue-200">
                <p class="text-blue-800">
                    <i class="fas fa-lightbulb text-blue-500 mr-2"></i>
                    当审查代码时，我经常发现初级开发者在类命名上犯错，尤其是将动词作为类名开头，或者使用小写字母开头的类名。这些看似小问题的命名错误会显著降低代码的专业度和可读性。
                </p>
            </div>
        </section>

        <!-- Section 2.2 -->
        <section id="class-mistakes" class="mb-16">
            <h3 class="text-2xl font-semibold mb-4 text-gray-800">类名常见错误与修正指南</h3>
            <p class="mb-6 text-gray-700">以下是我在代码审查中经常遇到的类命名错误及修正建议：</p>
            
            <div class="overflow-x-auto bg-white rounded-lg shadow-md card-hover">
                <table>
                    <thead>
                        <tr>
                            <th>不良命名</th>
                            <th>问题</th>
                            <th>改进命名</th>
                            <th>改进理由</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td><code>UserInfo</code></td>
                            <td>Info后缀无意义</td>
                            <td><code>User</code></td>
                            <td>去除多余后缀，更简洁</td>
                        </tr>
                        <tr>
                            <td><code>DAO</code></td>
                            <td>缩写不明确，技术实现泄露</td>
                            <td><code>CustomerRepository</code></td>
                            <td>使用完整词汇，抽象接口</td>
                        </tr>
                        <tr>
                            <td><code>ProcessOrders</code></td>
                            <td>动词开头，像方法</td>
                            <td><code>OrderProcessor</code></td>
                            <td>名词化，表示"是什么"</td>
                        </tr>
                        <tr>
                            <td><code>Util</code></td>
                            <td>过于宽泛</td>
                            <td><code>StringUtils</code>, <code>DateUtils</code></td>
                            <td>具体化职责范围</td>
                        </tr>
                        <tr>
                            <td><code>data</code></td>
                            <td>小写开头，过于宽泛</td>
                            <td><code>CustomerData</code></td>
                            <td>正确大小写，具体化</td>
                        </tr>
                        <tr>
                            <td><code>XMLHTTPRequest</code></td>
                            <td>暴露实现细节</td>
                            <td><code>DocumentLoader</code></td>
                            <td>抽象其意图而非实现</td>
                        </tr>
                    </tbody>
                </table>
            </div>
            
            <div class="mt-6 p-6 bg-white rounded-lg shadow-sm border border-gray-200">
                <p class="text-gray-700">
                    <i class="fas fa-check-circle text-green-500 mr-2"></i>
                    在团队协作中，一个好的类名可以清晰表达该类的职责和设计意图，避免其他开发者误用或混淆。特别是在面向对象设计中，类名是对抽象概念的命名，应该反映"是什么"而非"做什么"。
                </p>
            </div>
        </section>

        <!-- Section 3: Method Naming -->
        <section id="method-prefixes" class="mb-16">
            <h2 class="text-3xl font-bold mb-6 flex items-center">
                <span class="bg-purple-100 text-purple-800 w-10 h-10 rounded-full flex items-center justify-center mr-4">3</span>
                三、方法命名的艺术与实践模式
            </h2>
            
            <h3 class="text-2xl font-semibold mb-4 text-gray-800">方法命名动词前缀参考表</h3>
            <p class="mb-6 text-gray-700">方法表示行为，因此应以动词开头。不同类型的方法应使用不同的动词前缀来准确表达其意图：</p>
            
            <div class="overflow-x-auto bg-white rounded-lg shadow-md card-hover">
                <table>
                    <thead>
                        <tr>
                            <th>前缀类别</th>
                            <th>常用动词</th>
                            <th>语义</th>
                            <th>返回值特点</th>
                            <th>示例</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td><strong>获取型方法</strong></td>
                            <td><code>get</code>, <code>fetch</code>, <code>retrieve</code></td>
                            <td>获取数据</td>
                            <td>返回请求的数据</td>
                            <td><code>getUser()</code>, <code>fetchUserDetails()</code></td>
                        </tr>
                        <tr>
                            <td><strong>查询型方法</strong></td>
                            <td><code>find</code>, <code>search</code>, <code>query</code></td>
                            <td>查找数据</td>
                            <td>可能返回null或空集合</td>
                            <td><code>findById()</code>, <code>searchByName()</code></td>
                        </tr>
                        <tr>
                            <td><strong>判断型方法</strong></td>
                            <td><code>is</code>, <code>has</code>, <code>can</code>, <code>should</code></td>
                            <td>判断状态</td>
                            <td>返回布尔值</td>
                            <td><code>isValid()</code>, <code>hasPermission()</code></td>
                        </tr>
                        <tr>
                            <td><strong>转换型方法</strong></td>
                            <td><code>to</code>, <code>as</code>, <code>convert</code></td>
                            <td>数据转换</td>
                            <td>返回转换后的数据</td>
                            <td><code>toString()</code>, <code>asMap()</code></td>
                        </tr>
                        <tr>
                            <td><strong>操作型方法</strong></td>
                            <td><code>process</code>, <code>calculate</code>, <code>compute</code></td>
                            <td>数据处理</td>
                            <td>返回处理结果</td>
                            <td><code>processOrder()</code>, <code>calculateTotal()</code></td>
                        </tr>
                    </tbody>
                </table>
            </div>
            
            <div class="mt-6 p-6 bg-blue-50 rounded-lg border border-blue-200">
                <p class="text-blue-800">
                    <i class="fas fa-lightbulb text-blue-500 mr-2"></i>
                    严格遵循这些前缀约定可以让代码更具一致性和可预测性。例如，当我看到一个<code>get</code>开头的方法，我会期望它一定能返回请求的数据；而看到<code>find</code>开头的方法，我会知道结果可能为null。
                </p>
            </div>
        </section>

        <!-- Section 3.2 -->
        <section id="special-methods" class="mb-16">
            <h3 class="text-2xl font-semibold mb-4 text-gray-800">特殊方法命名约定表</h3>
            <p class="mb-6 text-gray-700">某些特殊用途的方法有其独特的命名约定：</p>
            
            <div class="overflow-x-auto bg-white rounded-lg shadow-md card-hover">
                <table>
                    <thead>
                        <tr>
                            <th>方法类型</th>
                            <th>命名规范</th>
                            <th>示例</th>
                            <th>注意事项</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td><strong>构造器</strong></td>
                            <td>与类名相同</td>
                            <td><code>public User()</code></td>
                            <td>应表达创建对象的特殊方式</td>
                        </tr>
                        <tr>
                            <td><strong>静态工厂方法</strong></td>
                            <td><code>from</code>, <code>of</code>, <code>valueOf</code>, <code>getInstance</code></td>
                            <td><code>List.of()</code>, <code>Integer.valueOf()</code></td>
                            <td>替代多个构造器的常用模式</td>
                        </tr>
                        <tr>
                            <td><strong>转换方法</strong></td>
                            <td><code>toXxx</code></td>
                            <td><code>toString()</code>, <code>toArray()</code></td>
                            <td>转换为不同表现形式</td>
                        </tr>
                        <tr>
                            <td><strong>适配方法</strong></td>
                            <td><code>asXxx</code></td>
                            <td><code>Path.asFile()</code></td>
                            <td>视图适配，不改变原对象</td>
                        </tr>
                        <tr>
                            <td><strong>JavaBean方法</strong></td>
                            <td><code>getXxx</code>, <code>setXxx</code>, <code>isXxx</code></td>
                            <td><code>getName()</code>, <code>setActive(boolean)</code></td>
                            <td>严格遵循Bean规范</td>
                        </tr>
                    </tbody>
                </table>
            </div>
            
            <div class="mt-6 p-6 bg-white rounded-lg shadow-sm border border-gray-200">
                <p class="text-gray-700">
                    <i class="fas fa-check-circle text-green-500 mr-2"></i>
                    这些特殊方法的命名约定在Java生态系统中已经形成了事实标准。例如，几乎所有Java开发者都期望<code>toString()</code>方法返回对象的字符串表示，这种一致性大大降低了学习和使用新API的成本。
                </p>
            </div>
        </section>

        <!-- Section 3.3 -->
        <section id="method-examples" class="mb-16">
            <h3 class="text-2xl font-semibold mb-4 text-gray-800">方法命名的对比示例</h3>
            <p class="mb-6 text-gray-700">以下是一些常见的方法命名问题及其改进建议：</p>
            
            <div class="overflow-x-auto bg-white rounded-lg shadow-md card-hover">
                <table>
                    <thead>
                        <tr>
                            <th>不良命名</th>
                            <th>问题</th>
                            <th>改进命名</th>
                            <th>代码示例</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td><code>process()</code></td>
                            <td>过于宽泛，不表达意图</td>
                            <td><code>processOrder()</code></td>
                            <td><code>public void processOrder(Order order) {...}</code></td>
                        </tr>
                        <tr>
                            <td><code>getData()</code></td>
                            <td>不明确获取什么数据</td>
                            <td><code>getUserProfile()</code></td>
                            <td><code>public UserProfile getUserProfile(long userId) {...}</code></td>
                        </tr>
                        <tr>
                            <td><code>check()</code></td>
                            <td>不清楚检查什么，返回什么</td>
                            <td><code>isValidCredential()</code></td>
                            <td><code>public boolean isValidCredential(String username, String password) {...}</code></td>
                        </tr>
                        <tr>
                            <td><code>doStuff()</code></td>
                            <td>完全不表达任何意图</td>
                            <td><code>calculateMonthlyReport()</code></td>
                            <td><code>public Report calculateMonthlyReport(Date date) {...}</code></td>
                        </tr>
                    </tbody>
                </table>
            </div>
            
            <div class="mt-6 p-6 bg-yellow-50 border-l-4 border-yellow-400 rounded">
                <p class="text-yellow-800">
                    <i class="fas fa-exclamation-triangle text-yellow-500 mr-2"></i>
                    我经常看到的一个严重问题是使用<code>process</code>、<code>handle</code>、<code>manage</code>等过于宽泛的动词，这些动词几乎可以用于任何操作，因此不能准确传达方法的实际作用。这种命名方式实质上是放弃了命名提供的自解释机会。
                </p>
            </div>
        </section>

        <!-- Section 4: Variable Naming -->
        <section id="variable-types" class="mb-16">
            <h2 class="text-3xl font-bold mb-6 flex items-center">
                <span class="bg-purple-100 text-purple-800 w-10 h-10 rounded-full flex items-center justify-center mr-4">4</span>
                四、变量命名的系统规范
            </h2>
            
            <h3 class="text-2xl font-semibold mb-4 text-gray-800">变量类型命名规则表</h3>
            <p class="mb-6 text-gray-700">不同类型的变量有着不同的命名规则：</p>
            
            <div class="overflow-x-auto bg-white rounded-lg shadow-md card-hover">
                <table>
                    <thead>
                        <tr>
                            <th>变量类型</th>
                            <th>命名规则</th>
                            <th>示例</th>
                            <th>反例</th>
                            <th>特别说明</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td><strong>局部变量</strong></td>
                            <td>camelCase</td>
                            <td><code>orderCount</code>, <code>userName</code></td>
                            <td><code>order_count</code>, <code>UserName</code></td>
                            <td>简短但有意义</td>
                        </tr>
                        <tr>
                            <td><strong>实例变量</strong></td>
                            <td>camelCase</td>
                            <td><code>connectionPool</code>, <code>userRepository</code></td>
                            <td><code>connection_pool</code>, <code>m_userRepository</code></td>
                            <td>避免使用this前缀除非必须区分</td>
                        </tr>
                        <tr>
                            <td><strong>静态变量</strong></td>
                            <td>camelCase</td>
                            <td><code>defaultPageSize</code>, <code>factoryInstance</code></td>
                            <td><code>DEFAULT_pagesize</code>, <code>FactoryInstance</code></td>
                            <td>非常量静态变量不使用全大写</td>
                        </tr>
                        <tr>
                            <td><strong>常量</strong></td>
                            <td>UPPER_SNAKE_CASE</td>
                            <td><code>MAX_RETRY_COUNT</code>, <code>DEFAULT_TIMEOUT</code></td>
                            <td><code>MaxRetryCount</code>, <code>defaultTimeout</code></td>
                            <td>真正不变的值才用全大写</td>
                        </tr>
                    </tbody>
                </table>
            </div>
            
            <div class="mt-6 p-6 bg-blue-50 rounded-lg border border-blue-200">
                <p class="text-blue-800">
                    <i class="fas fa-lightbulb text-blue-500 mr-2"></i>
                    值得注意的是，只有真正的常量（不会改变的静态final变量）才应使用全大写命名。一些可配置的静态final变量，例如通过配置文件设置的值，应该使用camelCase，因为从概念上讲它们并非真正的常量。
                </p>
            </div>
        </section>

        <!-- Section 4.2 -->
        <section id="collection-naming" class="mb-16">
            <h3 class="text-2xl font-semibold mb-4 text-gray-800">集合变量命名最佳实践</h3>
            <p class="mb-6 text-gray-700">集合类型的变量命名需要特别考虑：</p>
            
            <div class="overflow-x-auto bg-white rounded-lg shadow-md card-hover">
                <table>
                    <thead>
                        <tr>
                            <th>集合类型</th>
                            <th>推荐命名模式</th>
                            <th>示例</th>
                            <th>不推荐示例</th>
                            <th>命名理由</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td><strong>List/数组</strong></td>
                            <td>复数名词</td>
                            <td><code>List&lt;User&gt; users</code></td>
                            <td><code>List&lt;User&gt; userList</code></td>
                            <td>避免类型冗余，自然表达集合含义</td>
                        </tr>
                        <tr>
                            <td><strong>Map</strong></td>
                            <td>复数名词+By+键特性</td>
                            <td><code>Map&lt;String, User&gt; usersByName</code></td>
                            <td><code>Map&lt;String, User&gt; userMap</code></td>
                            <td>清晰表达映射关系</td>
                        </tr>
                        <tr>
                            <td><strong>Set</strong></td>
                            <td>独特性+复数名词</td>
                            <td><code>Set&lt;String&gt; uniqueNames</code></td>
                            <td><code>Set&lt;String&gt; nameSet</code></td>
                            <td>强调元素独特性</td>
                        </tr>
                        <tr>
                            <td><strong>嵌套集合</strong></td>
                            <td>描述层次关系</td>
                            <td><code>Map&lt;Department, List&lt;Employee&gt;&gt; employeesByDepartment</code></td>
                            <td><code>Map&lt;Department, List&lt;Employee&gt;&gt; data</code></td>
                            <td>表达数据结构和业务含义</td>
                        </tr>
                    </tbody>
                </table>
            </div>
            
            <div class="mt-6 p-6 bg-white rounded-lg shadow-sm border border-gray-200">
                <p class="text-gray-700">
                    <i class="fas fa-check-circle text-green-500 mr-2"></i>
                    关于集合命名的争论通常集中在是否应该包含类型信息上。现代观点倾向于避免在名称中包含类型信息（如<code>userList</code>），因为类型信息已经在声明中提供，而且如果稍后需要更改集合类型（例如从<code>List</code>到<code>Set</code>），包含类型的名称会变得误导。
                </p>
            </div>
        </section>

        <!-- Concept Diagram -->
        <section class="mb-16">
            <div class="bg-white rounded-xl shadow-md overflow-hidden card-hover">
                <div class="p-8">
                    <h3 class="text-2xl font-semibold mb-6 text-gray-800 flex items-center">
                        <i class="fas fa-project-diagram text-purple-500 mr-2"></i>
                        Java命名规范概念关系图
                    </h3>
                    <div class="mermaid">
                        graph TD
                            A[Java命名规范] --> B[类与接口命名]
                            A --> C[方法命名]
                            A --> D[变量命名]
                            
                            B --> B1[PascalCase]
                            B --> B2[名词或名词短语]
                            B --> B3[避免技术实现泄露]
                            
                            C --> C1[camelCase]
                            C --> C2[动词开头]
                            C --> C3[描述性优先]
                            C --> C4[特殊方法约定]
                            
                            D --> D1[camelCase/UPPER_SNAKE_CASE]
                            D --> D2[描述性]
                            D --> D3[避免类型前缀]
                            D --> D4[集合命名模式]
                    </div>
                </div>
            </div>
        </section>

        <!-- Key Takeaways -->
        <section class="mb-16">
            <div class="bg-purple-50 border border-purple-200 rounded-xl p-8">
                <h3 class="text-2xl font-semibold mb-6 text-purple-800 flex items-center">
                    <i class="fas fa-key text-purple-500 mr-2"></i>
                    关键要点总结
                </h3>
                <ul class="grid md:grid-cols-2 gap-6">
                    <li class="flex items-start">
                        <div class="bg-purple-100 text-purple-800 rounded-full w-8 h-8 flex items-center justify-center flex-shrink-0 mr-3">
                            <i class="fas fa-check"></i>
                        </div>
                        <div>
                            <h4 class="font-semibold text-gray-800 mb-1">一致性最重要</h4>
                            <p class="text-gray-700">选择一套命名规范并在整个项目中保持一致，比追求"完美"命名更重要。</p>
                        </div>
                    </li>
                    <li class="flex items-start">
                        <div class="bg-purple-100 text-purple-800 rounded-full w-8 h-8 flex items-center justify-center flex-shrink-0 mr-3">
                            <i class="fas fa-check"></i>
                        </div>
                        <div>
                            <h4 class="font-semibold text-gray-800 mb-1">描述性优先</h4>
                            <p class="text-gray-700">名称应准确描述其用途，避免过于宽泛或模糊的命名。</p>
                        </div>
                    </li>
                    <li class="flex items-start">
                        <div class="bg-purple-100 text-purple-800 rounded-full w-8 h-8 flex items-center justify-center flex-shrink-0 mr-3">
                            <i class="fas fa-check"></i>
                        </div>
                        <div>
                            <h4 class="font-semibold text-gray-800 mb-1">遵循行业惯例</h4>
                            <p class="text-gray-700">采用Google、Oracle等主流Java规范，而非创造自己的特殊规则。</p>
                        </div>
                    </li>
                    <li class="flex items-start">
                        <div class="bg-purple-100 text-purple-800 rounded-full w-8 h-8 flex items-center justify-center flex-shrink-0 mr-3">
                            <i class="fas fa-check"></i>
                        </div>
                        <div>
                            <h4 class="font-semibold text-gray-800 mb-1">避免技术债务</h4>
                            <p class="text-gray-700">糟糕的命名会累积成技术债务，在代码评审中应严格把关。</p>
                        </div>
                    </li>
                </ul>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-gray-300 py-12 px-4">
        <div class="max-w-6xl mx-auto">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-xl font-semibold text-white mb-2">技术小馆</h3>
                    <a href="http://www.yuque.com/jtostring" class="footer-link hover:text-blue-400 transition-colors">
                        <i class="fas fa-link mr-1"></i> http://www.yuque.com/jtostring
                    </a>
                </div>
                <div class="flex space-x-4">
                    <a href="#" class="footer-link hover:text-white transition-colors">
                        <i class="fab fa-github text-xl"></i>
                    </a>
                    <a href="#" class="footer-link hover:text-white transition-colors">
                        <i class="fab fa-twitter text-xl"></i>
                    </a>
                    <a href="#" class="footer-link hover:text-white transition-colors">
                        <i class="fab fa-linkedin text-xl"></i>
                    </a>
                </div>
            </div>
            <div class="mt-8 pt-8 border-t border-gray-800 text-center text-sm">
                <p>© 2023 技术小馆. 保留所有权利。</p>
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: false,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```